#include "Catalogo.h"
#include "Casillero.h"

Catalogo::Catalogo() {
	/*Coleccion de piezas que tienen instancias de las piezas validas, de aca se obtendran los atributos de cada pieza para crearla*/
	coleccionPiezas = new Pieza [CANTIDAD_PIEZAS];

	inicializarColores();

	crearPiezaA(AZUL);
	crearPiezaB(KHAKI);
	crearPiezaC(AMARILLO);
	crearPiezaD(CELESTE);
	crearPiezaE(GRIS);
	crearPiezaF(INDIGO);
	crearPiezaG(NARANJA);
	crearPiezaH(ROSA);
	crearPiezaI(ROJO);
	crearPiezaJ(VERDE);
	crearPiezaK(KHAKI);
}

Catalogo::~Catalogo() {

	delete [] this->coleccionPiezas; // el delete[] automaticamente llama al destructor de cada pieza individual
}
void Catalogo::inicializarColores(){
	AZUL.rojo=0;AZUL.verde=0;AZUL.azul=255;
	KHAKI.rojo=189;KHAKI.verde=183;KHAKI.azul=107;

	AMARILLO.rojo=255;AMARILLO.verde=215;AMARILLO.azul=0;
	CELESTE.rojo=0;CELESTE.verde=255;CELESTE.azul=255;

	GRIS.rojo=128;GRIS.verde=128;GRIS.azul=128;
	INDIGO.rojo=75;INDIGO.verde=0;INDIGO.azul=130;

	NARANJA.rojo=255;NARANJA.verde=69;NARANJA.azul=0;
	NEGRO.rojo=0;NEGRO.verde=0;NEGRO.azul=0;

	ROSA.rojo=255;ROSA.verde=20;ROSA.azul=147;
	ROJO.rojo=255;ROJO.verde=0;ROJO.azul=0;

	VERDE.rojo=0;VERDE.verde=255;VERDE.azul=0;
	VERDE_OSCURO.rojo=0;VERDE_OSCURO.verde=100;VERDE_OSCURO.azul=0;

}
Pieza* Catalogo::getPieza(char letra){

	Pieza *auxPieza=NULL ;
	Pieza* piezaADevolver;
	switch (letra){
	case 'A':
		auxPieza = &(this->coleccionPiezas[0]);
		break;
	case 'B':
		auxPieza = &(this->coleccionPiezas[1]);
		break;
	case 'C':
		auxPieza = &(this->coleccionPiezas[2]);
		break;
	case 'D':
		auxPieza = &(this->coleccionPiezas[3]);
		break;
	case 'E':
		auxPieza = &(this->coleccionPiezas[4]);
		break;
	case 'F':
		auxPieza = &(this->coleccionPiezas[5]);
		break;
	case 'G':
		auxPieza = &(this->coleccionPiezas[6]);
		break;
	case 'H':
		auxPieza = &(this->coleccionPiezas[7]);
		break;
	case 'I':
		auxPieza = &(this->coleccionPiezas[8]);
		break;
	case 'J':
		auxPieza = &(this->coleccionPiezas[9]);
		break;
	case 'K':
		auxPieza = &(this->coleccionPiezas[10]);
		break;
	default :
		//no hace nada si la letra no corresponde y devuelve NULL al final
		break;

	}

	if (auxPieza!=NULL) {
		piezaADevolver=new Pieza(*auxPieza);
		return piezaADevolver;
	}
	else return NULL;

}
void Catalogo::crearPiezaA(Color color){

		Casillero** forma_A;
		unsigned int filas=1;
		unsigned int columnas=1;


		forma_A=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_A[i]= new Casillero[filas];
		}
		forma_A[0][0].llenarCasillero(color);		//le carga algunos lugares llenos

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_A, columnas,filas);
		this->coleccionPiezas[0]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_A[i];
		}
		delete[] forma_A;


}
void Catalogo::crearPiezaB(Color color){

	Casillero** forma_B;
		unsigned int filas=2;
		unsigned int columnas=2;

		forma_B=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_B[i]= new Casillero[filas];
		}
		forma_B[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_B[0][1].llenarCasillero(color);
		forma_B[1][0].llenarCasillero(color);
		forma_B[1][1].llenarCasillero(color);

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_B,columnas, filas);
		this->coleccionPiezas[1]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_B[i];
		}
		delete[] forma_B;


}
void Catalogo::crearPiezaC(Color color){

	Casillero** forma_C;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_C=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_C[i]= new Casillero[filas];
		}
		forma_C[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_C[1][0].llenarCasillero(color);
		forma_C[2][0].llenarCasillero(color);
		forma_C[1][1].llenarCasillero(color);
		forma_C[1][2].llenarCasillero(color);


		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_C, columnas,filas);
		this->coleccionPiezas[2]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_C[i];
		}
		delete[] forma_C;

}
void Catalogo::crearPiezaD(Color color){

	Casillero** forma_D;
		unsigned int filas=3;
		unsigned int columnas=2;

		forma_D=new Casillero*[columnas];			//crea una matriz de casilleros
		for(unsigned int i=0;i<columnas;i++){
			forma_D[i]= new Casillero[filas];
		}
		forma_D[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_D[0][1].llenarCasillero(color);
		forma_D[0][2].llenarCasillero(color);
		forma_D[1][1].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_D, columnas,filas);
		this->coleccionPiezas[3]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_D[i];
		}
		delete[] forma_D;

}
void Catalogo::crearPiezaE(Color color){

	Casillero** forma_E;
		unsigned int filas=4;
		unsigned int columnas=1;

		forma_E=new Casillero*[columnas];			//crea una matriz de casilleros
			for(unsigned int i=0;i<columnas;i++){
				forma_E[i]= new Casillero[filas];
		}
		forma_E[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_E[0][1].llenarCasillero(color);
		forma_E[0][2].llenarCasillero(color);
		forma_E[0][3].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_E, columnas,filas);
		this->coleccionPiezas[4]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_E[i];
		}
		delete[] forma_E;

}
void Catalogo::crearPiezaF(Color color){

	Casillero** forma_F;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_F=new Casillero*[columnas];			//crea una matriz de casilleros
					for(unsigned int i=0;i<columnas;i++){
						forma_F[i]= new Casillero[filas];
				}
		forma_F[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_F[0][1].llenarCasillero(color);
		forma_F[0][2].llenarCasillero(color);

		forma_F[1][2].llenarCasillero(color);
		forma_F[2][2].llenarCasillero(color);




		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_F, columnas,filas);
		this->coleccionPiezas[5]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_F[i];
		}
		delete[] forma_F;

}
void Catalogo::crearPiezaG(Color color){

	Casillero** forma_G;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_G=new Casillero*[columnas];			//crea una matriz de casilleros
							for(unsigned int i=0;i<columnas;i++){
								forma_G[i]= new Casillero[filas];
						}
		forma_G[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_G[0][1].llenarCasillero(color);
		forma_G[0][2].llenarCasillero(color);

		forma_G[1][1].llenarCasillero(color);
		forma_G[2][1].llenarCasillero(color);
		forma_G[2][2].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_G, columnas,filas);
		this->coleccionPiezas[6]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_G[i];
		}
		delete[] forma_G;

}
void Catalogo::crearPiezaH(Color color){

	Casillero** forma_H;
		unsigned int filas=5;
		unsigned int columnas=3;

		forma_H=new Casillero*[columnas];			//crea una matriz de casilleros
									for(unsigned int i=0;i<columnas;i++){
										forma_H[i]= new Casillero[filas];
								}
		forma_H[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_H[2][0].llenarCasillero(color);
		forma_H[0][1].llenarCasillero(color);

		forma_H[1][1].llenarCasillero(color);
		forma_H[2][1].llenarCasillero(color);
		forma_H[1][2].llenarCasillero(color);
		forma_H[1][3].llenarCasillero(color);
		forma_H[1][4].llenarCasillero(color);



		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_H, columnas,filas);
		this->coleccionPiezas[7]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_H[i];
		}
		delete[] forma_H;

}
void Catalogo::crearPiezaI(Color color){

	Casillero** forma_I;
		unsigned int filas=3;
		unsigned int columnas=3;

		forma_I=new Casillero*[columnas];			//crea una matriz de casilleros
			for(unsigned int i=0;i<columnas;i++){
				forma_I[i]= new Casillero[filas];
			}
		forma_I[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_I[0][1].llenarCasillero(color);
		forma_I[0][2].llenarCasillero(color);

		forma_I[1][0].llenarCasillero(color);
		forma_I[1][1].llenarCasillero(color);
		forma_I[1][2].llenarCasillero(color);

		forma_I[2][0].llenarCasillero(color);
		forma_I[2][1].llenarCasillero(color);
		forma_I[2][2].llenarCasillero(color);


		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_I, columnas,filas);
		this->coleccionPiezas[8]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_I[i];
		}
		delete[] forma_I;

}
void Catalogo::crearPiezaJ(Color color){

	Casillero** forma_J;
		unsigned int filas=2;
		unsigned int columnas=1;

		forma_J=new Casillero*[columnas];			//crea una matriz de casilleros
			for(unsigned int i=0;i<columnas;i++){
				forma_J[i]= new Casillero[filas];
		}
		forma_J[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_J[0][1].llenarCasillero(color);

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_J, columnas,filas);
		this->coleccionPiezas[9]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_J[i];
		}
		delete[] forma_J;

}
void Catalogo::crearPiezaK(Color color){

	Casillero** forma_K;
		unsigned int filas=5;
		unsigned int columnas=3;

		forma_K=new Casillero*[columnas];			//crea una matriz de casilleros
					for(unsigned int i=0;i<columnas;i++){
						forma_K[i]= new Casillero[filas];
				}
		forma_K[0][0].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_K[1][0].llenarCasillero(color);
		forma_K[2][0].llenarCasillero(color);

		forma_K[0][1].llenarCasillero(color);		//le carga algunos lugares llenos

		forma_K[2][1].llenarCasillero(color);

		forma_K[0][2].llenarCasillero(color);		//le carga algunos lugares llenos


		forma_K[0][3].llenarCasillero(color);		//le carga algunos lugares llenos

		forma_K[2][3].llenarCasillero(color);

		forma_K[0][4].llenarCasillero(color);		//le carga algunos lugares llenos
		forma_K[1][4].llenarCasillero(color);
		forma_K[2][4].llenarCasillero(color);

		Pieza * pieza  = new Pieza();
		pieza->setForma(forma_K, columnas,filas);
		this->coleccionPiezas[10]=(*pieza);

		for(unsigned int i=0;i<columnas;i++){ // se libera la memoria de la matriz de casilleros, ya que la copia ya se guardo en la pieza
			delete[] forma_K[i];
		}
		delete[] forma_K;

}
